home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / procssng / compstol / cmpsttl1.lha / CompositeTool / v1.1.dist / HDF / dfr8.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-08  |  29.6 KB  |  850 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.00
  4. *                December, 1989
  5. *
  6. * NCSA HDF Version 3.00 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. /*-----------------------------------------------------------------------------
  23.  * File:    dfr8.c
  24.  * Purpose: read and write 8-bit Raster Image Groups
  25.  * Invokes: df.c, dfcomp.c, dfgroup.c, dfrig.h
  26.  * Contents: 
  27.  *  DFR8getdims: retrieve information about 8-bit image dimensions
  28.  *  DFR8getimage: retrieve 8-bit image and associated palette
  29.  *  DFR8setpalette: specify palette to be used with subsequent 8-bit images
  30.  *  DFR8Iputimage: internal routine that write 8-bit images to files
  31.  *  DFR8putimage: write 8-bit image into an HDF file
  32.  *  DFR8addimage: append another 8-bit image to an HDF file
  33.  *  DFR8getrig: read in a raster image group for 8-bit images
  34.  *  DFR8putrig: write out a raster image group for 8-bit images
  35.  *  DFR8nimages: number of images in HDF file
  36.  *  DFR8readref: get image with this reference number next
  37.  *  DFR8writeref: put image with this reference number next
  38.  *  DFR8restart: forget info about last file accessed - restart from beginning
  39.  *  DFR8lastref: return reference number of last element read or written
  40.  *  DFR8Iopen: open/reopen file
  41.  *  DFR8Iriginfo: obtain info about next RIG/RI8 to get
  42.  * Remarks: A RIG specifies attributes associated with an image - palette, 
  43.  *          dimension, compression, color compensation etc.
  44.  *          The palette for an 8-bit image is assumed to always be 768 bytes
  45.  *          The palette is arranged as RGBRGB...
  46.  *---------------------------------------------------------------------------*/
  47.  
  48.  
  49. #include "dfrig.h"
  50.  
  51. static int foundRig = -1;    /* -1: don't know if HDF file has RIGs */
  52.                 /* 0: No RIGs, try for RI8s etc. */
  53.                 /* 1: RIGs used, ignore RI8s etc. */
  54. static DFRrig Readrig;        /* information about RIG being read */
  55. static DFRrig Writerig;        /* information about RIG being written */
  56. static int Newdata = 0;        /* does Readrig contain fresh data? */
  57. static uint16 Writeref=0;    /* ref of next image to put in this file */
  58. static int Newpalette=(-1);    /* -1 = no palette is associated */
  59.                 /* 0 = palette already written out */
  60.                 /* 1 = new palette, not yet written out */
  61. static char Palette[768];    /* to store palette for 8-bit images */
  62. static uint16 Refset=0;        /* Ref of image to get next */
  63. static uint16 Lastref = 0;    /* Last ref read/written */
  64. static DFRrig Zrig = {        /* empty RIG for initialization */
  65.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  66.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  67.     {0, 0}, {0, 0, 0, 0, 0, 0, 0, 0},
  68.     0, 0, 0.0, 0.0, {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0},
  69.     {0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}, NULL
  70. };
  71.  
  72. #ifndef VMS
  73. DF *DFR8Iopen();
  74. #else /*VMS*/
  75. DF *_DFR8Iopen();
  76. #endif
  77.  
  78. typedef struct R8dim {
  79.     uint16 xd;
  80.     uint16 yd;
  81. } R8dim;            /* dimensions of raster-8 image */
  82.  
  83.  
  84. /*-----------------------------------------------------------------------------
  85.  * Name:    DFR8getdims
  86.  * Purpose: get dimensions of next image from RIG, also if there is a palette
  87.  * Inputs:  filename: name of HDF file
  88.  *          pxdim, pxdim, pointer to locations for returning x,y dimensions
  89.  *          pispal: pointer to location for rtning whether there is a palette
  90.  * Returns: 0 on success, -1 on failure with DFerror set
  91.  *          *pxdim, *pydim are set to dimensions of the next image
  92.  *          *pispal is set to 1 if a palette is associated with it, else 0
  93.  * Users:   HDF HLL (high-level library) users, utilities, other routines
  94.  * Invokes: DFR8Iopen, DFclose, DFR8Iriginfo, DFIerr
  95.  * Remarks: will also handle file with just raster-8 tags: RI8, CI8, ID8, IP8
  96.  *---------------------------------------------------------------------------*/
  97.  
  98. int DFR8getdims(filename, pxdim, pydim, pispal)
  99. char *filename;
  100. int32 *pxdim, *pydim;
  101. int *pispal;
  102. {
  103.     DF *dfile;
  104.  
  105.     DFerror = DFE_NOERROR;
  106.  
  107.     if (!pxdim || !pydim) {    /* check for zero dimensions */
  108.         DFerror = DFE_BADPTR;
  109.         return(-1);
  110.     }
  111.  
  112.     dfile = DFR8Iopen(filename, DFACC_READ);
  113.     if (dfile == NULL) return(-1);
  114.  
  115.     if (DFR8Iriginfo(dfile)<0)    /* reads next RIG or RI8 from file */
  116.         return(DFIerr(dfile));    /* on error, close file and return -1 */
  117.  
  118.     Newdata = 1;
  119.     *pxdim = Readrig.descimage.xdim;
  120.     *pydim = Readrig.descimage.ydim;
  121.     if (pispal) *pispal = Readrig.lut.tag ? 1 : 0; /* is there a palette */
  122.  
  123.     return(DFclose(dfile));
  124. }
  125.  
  126. /*-----------------------------------------------------------------------------
  127.  * Name:    DFR8getimage
  128.  * Purpose: get next image from a RIG, get palette also if desired
  129.  * Inputs:  filename: name of HDF file
  130.  *          image: space to read image into
  131.  *          xdim, ydim: dimensions of space allocated by user for image
  132.  *          pal: 768-byte space for palette, null if palette not wanted
  133.  * Returns: 0 on success, -1 on failure with DFerror set
  134.  *          image in image, palette in pal
  135.  * Users:   HDF HLL users, utilities, other routines
  136.  * Invokes: DFR8Iopen, DFR8Iriginfo, DFIerr, DFclose, DFgetelement, DFgetcomp
  137.  * Remarks: Will also get RI8s and CI8s if no RIGs in file
  138.  *          Normally,DFR8getdims is called first and it finds next image to get
  139.  *          But if that is not called, DFR8getimage will itself find next image
  140.  *          Automatically decompresses images
  141.  *---------------------------------------------------------------------------*/
  142.  
  143. int DFR8getimage(filename, image, xdim, ydim, pal)
  144. char *filename;
  145. int32 xdim, ydim;
  146. char *image;
  147. char *pal;
  148. {
  149.     DF *dfile;
  150.  
  151.     DFerror = DFE_NOERROR;
  152.  
  153.     if ((xdim<=0) || (ydim<=0)) {
  154.         DFerror = DFE_BADDIM;
  155.         return(-1);
  156.     }
  157.  
  158.     dfile = DFR8Iopen(filename, DFACC_READ);
  159.     if (dfile == NULL) return(-1);
  160.  
  161.     if (!Newdata) {        /* if Readrig not fresh */
  162.         if (DFR8Iriginfo(dfile)<0) /* reads next RIG or RI8 from file */
  163.             return(DFIerr(dfile)); /* on error, close file and return -1 */
  164.     }
  165.     Newdata = 0;        /* read new RIG next time */
  166.  
  167.     if ((Readrig.descimage.xdim > xdim) || (Readrig.descimage.ydim > ydim)) {
  168.         DFerror = DFE_NOTENOUGH; /* not enough space */
  169.         return(DFIerr(dfile));
  170.     }
  171.  
  172.     /* read image */
  173.     if (Readrig.descimage.compr.tag) { /* compressed image */
  174.         if (DFgetcomp(dfile, Readrig.image.tag, Readrig.image.ref, image,
  175.               Readrig.descimage.xdim, Readrig.descimage.ydim,
  176.               Readrig.descimage.compr.tag)<0)
  177.             return(DFIerr(dfile));
  178.     } else {            /* non-compressed raster image */
  179.         if (DFgetelement(dfile, Readrig.image.tag, Readrig.image.ref, image)<0)
  180.             return(DFIerr(dfile));
  181.     }
  182.  
  183.     if (pal && Readrig.lut.tag) { /* read palette */
  184.         if (DFgetelement(dfile, Readrig.lut.tag, Readrig.lut.ref, pal)<0)
  185.             return(DFIerr(dfile));
  186.     }
  187.     return(DFclose(dfile));
  188. }
  189.  
  190. /*-----------------------------------------------------------------------------
  191.  * Name:    DFR8setpalette
  192.  * Purpose: set palette for subsequent images
  193.  * Inputs:  pal: palette to set
  194.  * Returns: 0 on success, -1 on failure with DFerror set
  195.  * Users:   HDF users, utilities, other routines
  196.  * Invokes: none
  197.  * Remarks: if pal is NULL, no palette is associated with subsequent images
  198.  *---------------------------------------------------------------------------*/
  199.  
  200. int DFR8setpalette(pal)
  201. char *pal;
  202. {
  203.     int i;
  204.  
  205.     DFerror = DFE_NOERROR;
  206.  
  207.     if (!pal) {
  208.         Newpalette = -1;    /* no palette */
  209.         Writerig.lut.tag = 0;
  210.         Writerig.lut.ref = 0;   /* forget tag/ref of previous palette */
  211.         Writerig.desclut.xdim = 0;
  212.         Writerig.desclut.ncomponents = 0;
  213.     } else {            /* store palette */
  214.         for (i=0; i<768; i++)
  215.             Palette[i] = pal[i];
  216.         Newpalette = 1;
  217.     }
  218.     return(0);
  219. }
  220.  
  221. /*-----------------------------------------------------------------------------
  222.  * Name:    DFR8Iputimage
  223.  * Purpose: Internal routine to write RIG to file
  224.  * Inputs:  filename: name of HDF file
  225.  *          image: image to be written to file
  226.  *          xdim, ydim: dimensions of image
  227.  *          compress: compression scheme to be used on image, 0 if none
  228.  *                    possible values are DFTAG_RLE and DFTAG_IMC
  229.  *          op: 0 will overwrite existing file, 1 will append image to file
  230.  * Returns: 0 on success, -1 on failure with DFerror set
  231.  * Users:   HDF systems programmers, DFR8putimage, DFR8addimage
  232.  * Invokes: DFR8Iopen, DFclose, DFputelement, DFdup, DFR8putrig, DFputcomp,
  233.  *          DFIerr
  234.  * Remarks: Palette will be associated with image is isPalette is 1
  235.  *          Palette will be written to file if not written before (Palref=0)
  236.  *          Creates both RIG and RI8/CI8 tags, to accomodate older programs
  237.  *---------------------------------------------------------------------------*/
  238.  
  239. int DFR8Iputimage(filename, image, xdim, ydim, compress, op)
  240. char *filename;
  241. int32 xdim, ydim;
  242. char *image;
  243. int compress;               /* compression scheme */
  244. int op;                     /* 0 is a put, 1 is a putnext */
  245. {
  246.     int access;             /* create if op 0, write if op 1 */
  247.     DF *dfile;
  248.     uint16 r8tag;           /* RIG and raster tags of image being written */
  249.     char *pal;     /* pointer to palette to be written */
  250.     char newpal[768];  /* Imcomp creates new palette to be associated*/
  251.     int wdim;               /* have dimensions already been written out? */
  252.  
  253.     DFerror = DFE_NOERROR;
  254.  
  255.     if ((xdim<=0) || (ydim<=0)) {
  256.         DFerror = DFE_BADDIM;
  257.         return(-1);
  258.     }
  259.     if (!image) {
  260.         DFerror = DFE_BADPTR;
  261.         return(-1);
  262.     }
  263.     pal = (Newpalette>=0) ? Palette : NULL;
  264.     access = op ? DFACC_WRITE : DFACC_CREATE;
  265.  
  266.     dfile = DFR8Iopen(filename, access);
  267.     if (dfile==NULL) return(-1);
  268.  
  269.     if (!Writeref) Writeref = DFnewref(dfile);
  270.     if (!Writeref) return(-1);
  271.  
  272.     /* write out image */
  273.     if (compress) {
  274.         if (DFputcomp(dfile, DFTAG_CI, Writeref, image, xdim, ydim,
  275.               pal, newpal, compress)<0)
  276.             return(DFIerr(dfile));
  277.         Writerig.image.tag = DFTAG_CI;
  278.         if (compress==DFTAG_IMC) {
  279.             pal = newpal;    /* Imcomp creates new pal */
  280.             Newpalette = 1;    /* write out palette */
  281.         }
  282.     } else {            /* image need not be compressed */
  283.         if (DFputelement(dfile, DFTAG_RI, Writeref, image, xdim*ydim)<0)
  284.             return(DFIerr(dfile));
  285.         Writerig.image.tag = DFTAG_RI;
  286.     }
  287.     Writerig.image.ref = Writeref;
  288.     Writerig.descimage.ncomponents = 1;
  289.     Writerig.aspectratio = 1.0;
  290.  
  291.     /* Write out Raster-8 tags for those who want it */
  292.     r8tag = compress ?
  293.     ((compress==DFTAG_RLE) ? DFTAG_CI8 : DFTAG_II8) : DFTAG_RI8;
  294.     if (DFdup(dfile, r8tag, Writeref, Writerig.image.tag, Writeref)<0)
  295.         return(DFIerr(dfile));
  296.  
  297.     /* Write out palette */
  298.     if (pal) {            /* if there is a palette */
  299.         if (Newpalette==1) {    /* write palette */
  300.             if (DFputelement(dfile, DFTAG_LUT, Writeref, pal, (int32) 768)<0)
  301.                 return(DFIerr(dfile));
  302.             Writerig.lut.tag = DFTAG_LUT;
  303.             Writerig.lut.ref = Writeref;
  304.             Writerig.desclut.xdim = 768;
  305.             Writerig.desclut.ncomponents = 1;
  306.         }
  307.         if (compress!=DFTAG_IMC) Newpalette = 0;
  308.     /* if IMCOMP, original palette not written out */
  309.  
  310.     /* put in Raster-8 stuff also, for those who want it */
  311.         if (DFdup(dfile, DFTAG_IP8, Writeref, Writerig.lut.tag,
  312.           Writerig.lut.ref)<0)
  313.             return(DFIerr(dfile));
  314.     }
  315.  
  316.     /* Write out RIG */
  317.     if ((Writerig.descimage.xdim==xdim) && (Writerig.descimage.ydim==ydim) &&
  318.     (Writerig.descimage.compr.tag==compress))
  319.         wdim = 0;
  320.     else {
  321.         wdim = 1;
  322.         Writerig.descimage.xdim = xdim;
  323.         Writerig.descimage.ydim = ydim;
  324.         Writerig.descimage.compr.tag = compress;
  325.     }
  326.     if (DFR8putrig(dfile, Writeref, &Writerig, wdim)<0) /* writes ID, NT */
  327.         return(DFIerr(dfile));
  328.  
  329.     Lastref = Writeref;        /* remember ref written */
  330.  
  331.     Writeref = 0;               /* don't know ref to write next */
  332.  
  333.     return(DFclose(dfile));
  334. }
  335.  
  336. /*-----------------------------------------------------------------------------
  337.  * Name:    DFR8putimage
  338.  * Purpose: Write RIG to HDF file
  339.  * Inputs:  filename: name of HDF file
  340.  *          image: image to be written to file
  341.  *          xdim, ydim: dimensions of image
  342.  *          compress: compression scheme to be used on image, 0 if none
  343.  * Returns: 0 on success, -1 on failure with DFerror set
  344.  * Users:   HDF HLL users, utilities, other routines
  345.  * Invokes: DFR8Iputimage
  346.  * Remarks: overwrites existing HDF file
  347.  *---------------------------------------------------------------------------*/
  348.  
  349. int DFR8putimage(filename, image, xdim, ydim, compress)
  350. char *filename;
  351. int32 xdim, ydim;
  352. char *image;
  353. int compress;
  354. {
  355.     return(DFR8Iputimage(filename, image, xdim, ydim, compress, 0));
  356. }
  357.  
  358.  
  359. /*-----------------------------------------------------------------------------
  360.  * Name:    DFR8addimage
  361.  * Purpose: Append RIG to HDF file
  362.  * Inputs:  filename: name of HDF file
  363.  *          image: image to be written to file
  364.  *          xdim, ydim: dimensions of image
  365.  *          compress: compression scheme to be used on image, 0 if none
  366.  * Returns: 0 on success, -1 on failure with DFerror set
  367.  * Users:   HDF HLL users, utilities, other routines
  368.  * Invokes: DFR8Iputimage
  369.  * Remarks: inserts image into existing file, will create file if necessary
  370.  *---------------------------------------------------------------------------*/
  371.  
  372. int DFR8addimage(filename, image, xdim, ydim, compress)
  373. char *filename;
  374. int32 xdim, ydim;
  375. char *image;
  376. int compress;
  377. {
  378.     return(DFR8Iputimage(filename, image, xdim, ydim, compress, 1));
  379. }
  380.  
  381.  
  382. /*****************************************************************************/
  383. /* This is the next lower layer - procedures to get and put a RIG. */
  384. /* These are specific to 8-bit
  385. /*****************************************************************************/
  386.  
  387. /*-----------------------------------------------------------------------------
  388.  * Name:    DFR8getrig
  389.  * Purpose: Read a RIG into memory
  390.  * Inputs:  dfile: pointer to HDF file containing RIG
  391.  *          ref: reference number of RIG to get
  392.  *          rig: struct in which to place info obtained
  393.  * Returns: 0 on success, -1 on failure with DFerror set
  394.  *          contents of RIG in the struct rig
  395.  * Users:   HDF programmers, utilities, DFR8getdims,DFR8getimage
  396.  * Invokes: DFdiget, DFdinext, DFIcheck, DFgetelement
  397.  * Remarks: assumes 8-bit
  398.  *---------------------------------------------------------------------------*/
  399.  
  400. int DFR8getrig(dfile, ref, rig)
  401. DF *dfile;
  402. uint16 ref;
  403. DFRrig *rig;
  404. {
  405.     DFdi elmt;
  406.     char ntstring[4];
  407.  
  408.     DFerror = DFE_NOERROR;
  409.  
  410.     if (DFIcheck(dfile))
  411.         return( -1);
  412.     if (!ref) {
  413.         DFerror = DFE_BADREF;
  414.         return(-1);
  415.     }
  416.  
  417.     if (DFdiread(dfile, DFTAG_RIG, ref)<0) /* read RIG into memory */
  418.         return(-1);
  419.  
  420.     *rig = Zrig;        /* fill rig with zeroes */
  421.     while (!DFdiget(&elmt)) {    /* get next tag/ref from RIG */
  422.         switch (elmt.tag) {    /* process tag/ref */
  423.             case DFTAG_CI:
  424.             case DFTAG_RI:
  425.                 rig->image.tag = elmt.tag; /* put tag/ref in struct */
  426.                 rig->image.ref = elmt.ref;
  427.                 break;
  428.             case DFTAG_LUT:
  429.                 rig->lut.tag = elmt.tag;
  430.                 rig->lut.ref = elmt.ref;
  431.                 break;
  432.             case DFTAG_ID:    /* read description info */
  433. #ifdef DF_STRUCTOK
  434.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, &rig->descimage)<0)
  435.                     return(-1);
  436. #else /*DF_STRUCTOK*/
  437.                 if (DFgetelement(dfile, elmt.tag, elmt.ref, DFtbuf)>0) {
  438.                     register char *p;
  439.                     p = DFtbuf;
  440.                     INT32READ(p, rig->descimage.xdim);
  441.                     INT32READ(p, rig->descimage.ydim);
  442.                     UINT16READ(p, rig->descimage.nt.tag);
  443.                     UINT16READ(p, rig->descimage.nt.ref);
  444.                     INT16READ(p, rig->descimage.ncomponents);
  445.                     INT16READ(p, rig->descimage.interlace);
  446.                     UINT16READ(p, rig->descimage.compr.tag);
  447.                     UINT16READ(p, rig->descimage.compr.ref);
  448.                 } else
  449.                     return(-1);
  450. #endif /*DF_STRUCTOK*/
  451.                 if (rig->descimage.ncomponents!=1) {
  452.                     DFerror = DFE_BADCALL;
  453.                     return(-1);
  454.                 }
  455.                 if (rig->descimage.nt.tag==0) break; /* old RIGs */
  456.  
  457.         /* read NT */
  458.                 if (DFgetelement(dfile, rig->descimage.nt.tag,
  459.                  rig->descimage.nt.ref, ntstring)<0)
  460.                     return(-1);
  461.                 if ((ntstring[2]!=8) || (ntstring[1]!=DFNT_UCHAR)) {
  462.                     DFerror = DFE_BADCALL;
  463.                     return(-1);
  464.                 }
  465.                 break;
  466.             default:        /* ignore unknown tags */
  467.                 break;
  468.         }
  469.     }
  470.     return(0);
  471. }
  472.  
  473. /*-----------------------------------------------------------------------------
  474.  * Name:    DFR8putrig
  475.  * Purpose: Write RIG struct out to HDF file
  476.  * Inputs:  dfile: HDF file pointer
  477.  *          ref: ref to put RIG with
  478.  *          rig: struct containing RIG info to put
  479.  *          wdim: if 1, write out new description records. if 0 already written
  480.  * Returns: 0 on success, -1 on failure with DFerror set
  481.  * Users:   HDF programmers, utilities, DFR8Iputimage, other routines
  482.  * Invokes: DFIcheck, DFdistart, DFdiadd, DFdiend, DFputelement
  483.  * Remarks: assumes 8-bit.  Writes out NT if necessary, ID, ID8 if told to
  484.  *---------------------------------------------------------------------------*/
  485.  
  486. int DFR8putrig(dfile, ref, rig, wdim)
  487. DF *dfile;
  488. uint16 ref;
  489. DFRrig *rig;
  490. int wdim;
  491. {
  492.     static uint16 prevdimref=0; /*ref of previous dimension record, to reuse */
  493.     R8dim im8dim;
  494.     char ntstring[4];
  495.  
  496.     DFerror = DFE_NOERROR;
  497.  
  498.     if (DFIcheck(dfile))
  499.         return( -1);
  500.     if (!ref) {
  501.         DFerror = DFE_BADREF;
  502.         return(-1);
  503.     }
  504.  
  505.     if (!rig->descimage.nt.tag) {
  506.     /* construct and write out NT */
  507.         ntstring[0] = DFNT_VERSION; /* version */
  508.         ntstring[1] = DFNT_UCHAR; /* type */
  509.         ntstring[2] = 8;    /* width: RIG data is 8-bit chars */
  510.         ntstring[3] = DFNTC_BYTE; /* class: data are numeric values */
  511.         if (DFputelement(dfile, DFTAG_NT, ref, ntstring, (int32) 4) <0)
  512.             return(-1);
  513.         rig->descimage.nt.tag = DFTAG_NT;
  514.         rig->descimage.nt.ref = ref;
  515.     }
  516.         
  517.     im8dim.xd = rig->descimage.xdim;
  518.     im8dim.yd = rig->descimage.ydim;
  519.     if (wdim) {
  520. #ifdef DF_STRUCTOK        /* write out description record */
  521.         if (DFputelement(dfile, DFTAG_ID8, ref, &im8dim, (int32) 4)<0) /*ID8 */
  522.             return(-1);
  523.         if (DFputelement(dfile, DFTAG_ID, ref, &rig->descimage,    /* ID */
  524.              sizeof(rig->descimage))<0)
  525.             return(-1);
  526. #else /*DF_STRUCTOK*/
  527.         register char *p;
  528.         p = DFtbuf;
  529.         INT32WRITE(p, rig->descimage.xdim);
  530.         INT32WRITE(p, rig->descimage.ydim);
  531.         UINT16WRITE(p, rig->descimage.nt.tag);
  532.         UINT16WRITE(p, rig->descimage.nt.ref);
  533.         INT16WRITE(p, rig->descimage.ncomponents);
  534.         INT16WRITE(p, rig->descimage.interlace);
  535.         UINT16WRITE(p, rig->descimage.compr.tag);
  536.         UINT16WRITE(p, rig->descimage.compr.ref);
  537.         if (DFputelement(dfile, DFTAG_ID, ref, DFtbuf,(int32)(p-DFtbuf))<0)
  538.             return(-1);
  539.     /* write out ID8 */
  540.         p = DFtbuf;
  541.         UINT16WRITE(p, im8dim.xd);
  542.         UINT16WRITE(p, im8dim.yd);
  543.         if (DFputelement(dfile, DFTAG_ID8, ref, DFtbuf, (int32) 4)<0)
  544.             return(-1);
  545. #endif /*DF_STRUCTOK*/
  546.         prevdimref = ref;
  547.     }
  548.     if (!prevdimref) {
  549.         DFerror = DFE_BADDIM;
  550.         return(-1);
  551.     }
  552.  
  553.     /* prepare to start writing rig */
  554.     /* ### NOTE: the second parameter to this call may go away */
  555.     if (DFdisetup(10)<0) return(-1); /* max 10 tag/refs in set */
  556.  
  557.     /* add tag/ref to RIG - image description, image and palette */
  558.     if (DFdiput(DFTAG_ID, prevdimref) < 0) return(-1);
  559.  
  560.     if (DFdiput(rig->image.tag, rig->image.ref) < 0) return(-1);
  561.  
  562.     if (rig->lut.ref)
  563.         if (DFdiput(rig->lut.tag, rig->lut.ref) < 0) return(-1);
  564.  
  565.         /* write out RIG */
  566.     return(DFdiwrite(dfile, DFTAG_RIG, ref));
  567. }
  568.  
  569.  
  570. /*-----------------------------------------------------------------------------
  571.  * Name:    DFR8nimages
  572.  * Purpose: How many images are present in this file?
  573.  * Inputs:  filename: name of HDF file
  574.  * Returns: number of images  on success, -1 on failure with DFerror set
  575.  * Users:   HDF programmers, other routines and utilities
  576.  * Invokes: DFR8Iopen, DFclose, DFnumber
  577.  * Remarks: the number is the number of RIGs if RIGs are present
  578.  *          If not, it is the number of RI8s + number of CI8s
  579.  *---------------------------------------------------------------------------*/
  580.  
  581. int DFR8nimages(filename)
  582. char *filename;
  583. {
  584.     DF *dfile;
  585.     int nimages=0;
  586.  
  587.     DFerror = DFE_NOERROR;
  588.  
  589.     /* should use reopen if same file as last time - more efficient */
  590.     dfile = DFR8Iopen(filename, DFACC_READ);
  591.     if (dfile==NULL) return(-1);
  592.  
  593.     /* find next rig */
  594.     if (foundRig) {        /* either RIGs present or don't know */
  595.         nimages = DFnumber(dfile, DFTAG_RIG); /* count number of RIGs */
  596.         if (nimages>=0) {
  597.             foundRig = 1;
  598.             if (DFclose(dfile)<0) return(-1);
  599.             return(nimages);
  600.         }
  601.         foundRig = 0;
  602.     }
  603.     nimages = DFnumber(dfile, DFTAG_RI8);
  604.     nimages += DFnumber(dfile, DFTAG_CI8);
  605.     if (DFclose(dfile)<0) return(-1);
  606.     return(nimages);
  607. }
  608.  
  609. /*-----------------------------------------------------------------------------
  610.  * Name:    DFR8readref
  611.  * Purpose: Set ref of image to get next
  612.  * Inputs:  filename: file to which this applies
  613.  *          ref: reference number of next get
  614.  * Returns: 0 on success, -1 on failure
  615.  * Users:   HDF programmers, other routines and utilities
  616.  * Invokes: DFR8Iopen, DFIfind
  617.  * Remarks: checks if image with this ref exists
  618.  *---------------------------------------------------------------------------*/
  619.  
  620. int DFR8readref(filename, ref)
  621. char *filename;
  622. uint16 ref;
  623. {
  624.     DF *dfile;
  625.     int cdd;
  626.     DFdle *dlep;
  627.  
  628.     DFerror = DFE_NOERROR;
  629.  
  630.     dfile = DFR8Iopen(filename, DFACC_READ);
  631.     if (dfile==NULL) return(-1);
  632.     if (DFIfind(dfile, DFTAG_RIG, ref, 1, 0, 0, &dlep, &cdd)<0)
  633.         if (DFIfind(dfile, DFTAG_RI8, ref, 1, 0, 0, &dlep, &cdd)<0)
  634.             if (DFIfind(dfile, DFTAG_CI8, ref, 1, 0, 0, &dlep, &cdd)<0)
  635.                 return(DFIerr(dfile));
  636.     Refset = ref;
  637.     return(DFclose(dfile));
  638. }
  639.  
  640. /*-----------------------------------------------------------------------------
  641.  * Name:    DFR8writeref
  642.  * Purpose: Set ref of image to put next
  643.  * Inputs:  filename: file to which this applies
  644.  *          ref: reference number of next put
  645.  * Returns: 0 on success, -1 on failure
  646.  * Users:   HDF programmers, other routines and utilities
  647.  * Invokes: DFR8Iopen, DFIfind
  648.  * Remarks: none
  649.  *---------------------------------------------------------------------------*/
  650.  
  651. /* shut lint up */
  652. /* ARGSUSED */
  653. int DFR8writeref(filename, ref)
  654. char *filename;
  655. uint16 ref;
  656. {
  657.     DFerror = DFE_NOERROR;
  658.  
  659.     Writeref = ref;
  660.     return(0);
  661. }
  662.  
  663. static char Lastfile[DF_MAXFNLEN];          /* last file opened */
  664.  
  665. /*-----------------------------------------------------------------------------
  666.  * Name:    DFR8restart
  667.  * Purpose: Do not remember info about file - get again from first image
  668.  * Inputs:  none
  669.  * Returns: 0 on success
  670.  * Users:   HDF programmers
  671.  * Remarks: Just reset Lastfile to NULL
  672.  *---------------------------------------------------------------------------*/
  673.  
  674. int DFR8restart()
  675. {
  676.     Lastfile[0] = '\0';
  677.     return(0);
  678. }
  679.  
  680.  
  681. /*-----------------------------------------------------------------------------
  682.  * Name:    DFR8lastref
  683.  * Purpose: Return last ref written or read
  684.  * Inputs:  none
  685.  * Globals: Lastref
  686.  * Returns: ref on success, -1 on error with DFerror set
  687.  * Users:   HDF users, utilities, other routines
  688.  * Invokes: none
  689.  * Method:  return Lastref
  690.  * Remarks: none
  691.  *---------------------------------------------------------------------------*/
  692.  
  693. int DFR8lastref()
  694. {
  695.     return((int) Lastref);
  696. }
  697.  
  698.  
  699.  
  700. /******************************************************************************/
  701. /*----------------------- Internal routines ---------------------------------*/
  702. /******************************************************************************/
  703.  
  704.  
  705. /*-----------------------------------------------------------------------------
  706.  * Name:    DFR8Iopen
  707.  * Purpose: open or reopen a file
  708.  * Inputs:  filename: name of file to open
  709.  *          access : access mode
  710.  * Returns: file pointer on success, NULL on failure with DFerror set
  711.  * Users:   HDF systems programmers, all the RIG routines 
  712.  * Invokes: DFopen
  713.  * Remarks: This is a hook for someday providing more efficient ways to
  714.  *          reopen a file, to avoid re-reading all the headers
  715.  *---------------------------------------------------------------------------*/
  716.  
  717. DF *DFR8Iopen(filename, access)
  718. char *filename;
  719. int access;
  720. {
  721.  
  722.     DF *dfile;
  723.  
  724.     /* use reopen if same file as last time - more efficient */
  725.     if (strncmp(Lastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  726.                 /* treat create as different file */
  727.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  728.         foundRig = -1;        /* don't know if any RIGs in file */
  729.         Refset = 0;        /* no ref to get set for this file */
  730.         Newdata = 0;
  731.         Readrig = Zrig;        /* blank out read/write RIGs */
  732.         Writerig = Zrig;
  733.         if (Newpalette!=(-1)) Newpalette = 1; /* need to write out palette */
  734.     } else
  735.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  736.  
  737.     strncpy(Lastfile, filename, DF_MAXFNLEN);
  738.     /* remember filename, so reopen may be used next time if same file */
  739.     return(dfile);
  740. }
  741.  
  742. /*-----------------------------------------------------------------------------
  743.  * Name:    DFR8Iriginfo
  744.  * Purpose: Getinformation about next RIG or Raster-8 in file
  745.  * Inputs:  dfile: pointer to DF file
  746.  * Returns: 0 on success, -1 on failure with DFerror set
  747.  * Users:   HDF systems programmers
  748.  * Invokes: DFIfind, DFgetelement
  749.  * Remarks: checks for RIGs first, then RI8s
  750.  *          if Refset set, gets image with that ref, if any
  751.  *---------------------------------------------------------------------------*/
  752.  
  753. int DFR8Iriginfo(dfile)
  754. DF *dfile;
  755. {
  756.     DFdle *dlep;
  757.     int cdd;
  758.     uint16 riref=0, ciref=0;
  759.  
  760. #ifdef DF_STRUCTOK
  761.     R8dim im8dim;
  762. #endif /*DF_STRUCTOK*/
  763.  
  764.     /* find next rig */
  765.     if (foundRig) {        /* either RIGs present or don't know */
  766.     do {
  767.         DFerror = DFE_NOERROR;
  768.         if (Refset &&
  769.         DFIfind(dfile, DFTAG_RIG, Refset, 1,0,0, &dlep, &cdd)<0) {
  770.         /* try for RI8 and CI8s */
  771.         }
  772.             /* in next line, !ref is passed for isfirst.  If we have found
  773.            a ref before, ref is non-zero, hence isfirst is 0.  If
  774.            we have not found anything yet, ref is 0 and isfirst is 1 */
  775.         else if (!Refset && DFIfind(dfile, DFTAG_RIG, DFREF_WILDCARD,
  776.                     !Readrig.image.ref, Readrig.image.tag,
  777.                                         Readrig.image.ref, &dlep, &cdd) <0) {
  778.         if (foundRig==1) { /* RIGs present, but no more to return */
  779.             DFerror = DFE_NOMATCH;
  780.             return(-1);
  781.         }
  782.         foundRig = 0;    /* No RIGs present in file */
  783.         }
  784.         else {        /* RIG found */
  785.         if (DFR8getrig(dfile, dlep->dd[cdd].ref, &Readrig)<0) {
  786.             if (Refset || (DFerror != DFE_BADCALL)) {
  787.             Refset = 0;
  788.             return(-1);
  789.             }
  790.             Readrig.image.ref = dlep->dd[cdd].ref; /*to get next one */
  791.         } else { foundRig = 1; Refset = 0; }
  792.         }
  793.     } while (DFerror==DFE_BADCALL);
  794.     }
  795.     if (Refset || !foundRig) {    /* No RIGs present, look for RI8 and CI8 */
  796.     /* look for Refset if DFR8ref called, else look for next ref */
  797.         if ((Refset &&
  798.          (DFIfind(dfile, DFTAG_RI8, Refset, 1, 0, 0, &dlep, &cdd)==0)) ||
  799.         (!Refset &&
  800.          (DFIfind(dfile, DFTAG_RI8, DFREF_WILDCARD, !Readrig.image.ref,
  801.               Readrig.image.tag, Readrig.image.ref, &dlep, &cdd)==0)))
  802.             riref = dlep->dd[cdd].ref;
  803.  
  804.         if ((Refset &&
  805.          (DFIfind(dfile, DFTAG_CI8, Refset, 1, 0, 0, &dlep, &cdd)==0)) ||
  806.         (!Refset &&
  807.          (DFIfind(dfile, DFTAG_CI8, DFREF_WILDCARD, !Readrig.image.ref,
  808.               Readrig.image.tag, Readrig.image.ref, &dlep, &cdd)==0)))
  809.             ciref = dlep->dd[cdd].ref;
  810.  
  811.         Refset = 0;
  812.         if (!riref && !ciref) {
  813.             DFerror = DFE_NOMATCH;
  814.             return(-1);
  815.         }
  816.         if ((!ciref) || (riref && (riref<ciref))) { /* next image is RI8 */
  817.             Readrig.image.ref = riref;
  818.             Readrig.image.tag = DFTAG_RI8;
  819.         }
  820.         else {            /* next image is CI8 */
  821.             Readrig.image.ref = ciref;
  822.             Readrig.image.tag = DFTAG_CI8;
  823.             Readrig.descimage.compr.tag = DFTAG_RLE;
  824.         }
  825.  
  826. #ifdef DF_STRUCTOK        /* read in dimensions */
  827.         if (DFgetelement(dfile, DFTAG_ID8, Readrig.image.ref, &im8dim)>=0) {
  828.             Readrig.descimage.xdim = im8dim.xd;
  829.             Readrig.descimage.ydim = im8dim.yd;
  830.         }
  831. #else /*DF_STRUCTOK*/
  832.         if (DFgetelement(dfile, DFTAG_ID8, Readrig.image.ref, DFtbuf)>=0) {
  833.             register char *p;
  834.             p = DFtbuf;
  835.             UINT16READ(p, Readrig.descimage.xdim);
  836.             UINT16READ(p, Readrig.descimage.ydim);
  837.         }
  838. #endif /*DF_STRUCTOK*/
  839.         else return(-1);
  840.  
  841.         if (DFIfind(dfile, DFTAG_IP8, Readrig.image.ref, 1, 0, 0, &dlep,
  842.             &cdd)==0) {
  843.             Readrig.lut.tag = DFTAG_IP8;
  844.             Readrig.lut.ref = Readrig.image.ref;
  845.         }
  846.     }
  847.     Lastref = Readrig.image.ref; /* remember ref read */
  848.     return(0);
  849. }
  850.